package com.xpf.controller;

import com.xpf.pojo.Users;
import com.xpf.pojo.vo.UserVO;
import com.xpf.service.UserService;
import com.xpf.utils.JSONResult;
import com.xpf.utils.JsonUtils;
import com.xpf.utils.MD5Utils;
import com.xpf.utils.RedisOperator;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.UUID;

@Controller
public class SSOController {

    @Autowired
    private UserService userService;

    @Autowired
    private RedisOperator redisOperator;

    public static final String REDIS_USER_TOKEN = "redis_user_token";
    public static final String REDIS_USER_TICKET = "redis_user_ticket";
    public static final String REDIS_TMP_TICKET = "redis_tmp_ticket";
    public static final String COOKIE_USER_TICKET = "cookie_user_ticket";

    @GetMapping("/login")
    public String login(String returnUrl, Model model,
                        HttpServletRequest request, HttpServletResponse response){
        model.addAttribute("returnUrl" , returnUrl); //这个要和login.html中的hidden隐藏框的value对应

        //1、获取userTicket门票，如果cookie中能够获取到，说明用户登录过，此时签发一个一次性的临时门票
        String userTicket = getCookie(request, COOKIE_USER_TICKET);

        boolean isVerified = verifyUserTicket(userTicket);
        if (isVerified){
            String tmpTicket = createTmpTicket();
            return "redirect:" + returnUrl + "?tmpTicket=" + tmpTicket;
        }

        //2、用户从未登录，第一次登录则跳转到CAS登录页面
        return "login";
    }

    /**
     * 校验CAS全局用户门票
     * @param userTicket
     * @return
     */
    private boolean verifyUserTicket(String userTicket){
        //0. 验证CAS全局门票不能为空
        if (StringUtils.isBlank(userTicket)){
            return false;
        }
        //1、验证CAS门票是否有效
        String userId = redisOperator.get(REDIS_USER_TICKET + ":" + userTicket);
        if (StringUtils.isBlank(userId)){
            return false;
        }
        //2、验证门票对应的user会话是否存在
        String userRedis = redisOperator.get(REDIS_USER_TOKEN + ":" + userId);
        if (StringUtils.isBlank(userRedis)){
            return false;
        }

        return true;
    }

    /**
        CAS的统一登录接口
            目的：
                1、登录后创建用户的全局会话                   -> uniqueToken
                2、创建用户的全局门票，用以表示在CAS端是否登录   -> userTicket
                3、创建用户的临时票据，用户回跳回传            -> tmpTicket
     */
    @PostMapping("/doLogin")
    public String doLogin(
            String username, String password,
            String returnUrl, Model model,
            HttpServletRequest request, HttpServletResponse response) throws Exception {

        model.addAttribute("returnUrl" , returnUrl);
        //1 用户登录
        //①用户名和密码不能为空
        if (StringUtils.isBlank(username) || StringUtils.isBlank(password) ){
            model.addAttribute("errmsg","用户名或密码不能为空");
            return "login";
        }
        //②用户登录
        Users userResult = userService.queryUserForLogin(username, MD5Utils.getMD5Str(password));
        if (userResult == null){
            model.addAttribute("errmsg","用户名或密码错误");
            return "login";
        }
        //2. 生成用户token，存入redis会话(实现用户redis会话)
        String uniqueToken = UUID.randomUUID().toString().trim();
        UserVO userVO = new UserVO();
        BeanUtils.copyProperties(userResult, userVO);
        userVO.setUserUniqueToken(uniqueToken);
        redisOperator.set(REDIS_USER_TOKEN + ":"+ userResult.getId(), JsonUtils.objectToJson(userVO));

        // 3. 生成ticket门票，全局门票，代表用户在CAS端登录过
        String userTicket = UUID.randomUUID().toString().trim();
        // 3.1 用户全局门票需要放入CAS端的cookie中
        setCookie(COOKIE_USER_TICKET, userTicket, response);

        //4. userTicket关联用户id，并且放入到redis中，代表这个用户有门票了，可以在各个景区（网站）游玩
        redisOperator.set(REDIS_USER_TICKET+ ":" + userTicket, userResult.getId());

        //5. 生成临时票据，存入redis，回跳到调用端网站，并携带由CAS端签发的一个一次性的临时ticket
        String tmpTicket = createTmpTicket();

//        return "login";
        return "redirect:" + returnUrl + "?tmpTicket=" + tmpTicket;

        /** 注：
         * userTicket: 用于表示用户在CAS端的一个登录状态：已登录
         * tmpTicket: 用于颁发给用户进行一次性的验证的票据，有时效性
         */
    }

    @PostMapping("/verifyTmpTicket")
    @ResponseBody
    public JSONResult verifyTmpTicket(String tmpTicket,
                                      HttpServletRequest request,
                                      HttpServletResponse response) throws Exception {
        //使用一次性临时票据来验证用户是否登录，如果登录过，则把用户会话信息放回给站点
        //使用完毕后，需要销毁临时票据
        String tmpTicketValue = redisOperator.get(REDIS_TMP_TICKET + ":" + tmpTicket);
        if (StringUtils.isBlank(tmpTicketValue)){
            return JSONResult.errorUserTicket("用户票据异常1");
        }

        //0. 如果临时票据验证通过，则需要销毁，并且拿到CAS端cookie中的全局userTicket，以此再获取用户的会话
        if (!tmpTicketValue.equals(MD5Utils.getMD5Str(tmpTicket))){
            return JSONResult.errorUserTicket("用户票据异常2");
        }else {
            //销毁临时票据
            redisOperator.del(REDIS_TMP_TICKET + ":" + tmpTicket);
        }

        // 1. 验证并且获取用户的userTicket（拿到CAS端cookie中的全局userTicket）
        // todo 拿不到cookie 暂时想不明白
        String userTicket = getCookie(request, COOKIE_USER_TICKET);
        String userId = redisOperator.get(REDIS_USER_TICKET + ":" + userTicket);
        if (StringUtils.isBlank(userId)){
            return JSONResult.errorUserTicket("用户票据异常3");
        }

        //2. 验证门票对应的user会话是否存在
        String userRedis = redisOperator.get(REDIS_USER_TOKEN + ":" + userId);
        if (StringUtils.isBlank(userRedis)){
            return JSONResult.errorUserTicket("用户票据异常4");
        }
        // 验证成功，返回ok，携带用户会话
        return JSONResult.ok(JsonUtils.jsonToPojo(userRedis,UserVO.class));
    }

    /**
     * 退出登录
     * @param userId
     * @return
     */
    @PostMapping("/logout")
    @ResponseBody
    public JSONResult logout(String userId, HttpServletRequest request, HttpServletResponse response){
        if (StringUtils.isBlank(userId)){
            return JSONResult.errorMsg("用户id为空");
        }

        //0.获取CAS中的用户门票
        String userTicket = getCookie(request, COOKIE_USER_TICKET);
        //1. 清除userTicket票据，redis/cookie
        deleteCookie(COOKIE_USER_TICKET, response);
        redisOperator.del(REDIS_USER_TICKET + ":" + userTicket);
        //2. 清除用户全局会话（分布式会话）
        redisOperator.del(REDIS_USER_TOKEN + ":" + userId);
        return JSONResult.ok();
    }

    /**
     * 创建临时票据
     * @return
     */
    private String createTmpTicket(){
        String tmpTicket = UUID.randomUUID().toString().trim();
        try {
            redisOperator.set(REDIS_TMP_TICKET + ":" + tmpTicket, MD5Utils.getMD5Str(tmpTicket),600);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return tmpTicket;
    }

    private void setCookie(String key, String val, HttpServletResponse response){
        Cookie cookie = new Cookie(key, val);
        cookie.setDomain("sso.com");
        cookie.setPath("/");
        response.addCookie(cookie);
    }

    private String getCookie(HttpServletRequest request, String key){
        Cookie[] cookies = request.getCookies();
        if (cookies == null || StringUtils.isBlank(key)){
            return null;
        }

        Cookie cookieVal = null;
        for (Cookie cookie : cookies) {
            if (key.equals(cookie.getName())){
                cookieVal = cookie;
                break;
            }
        }
        return cookieVal.getValue();
    }

    private void deleteCookie(String key, HttpServletResponse response){
        Cookie cookie = new Cookie(key, null);
        cookie.setDomain("sso.com");
        cookie.setPath("/");
        cookie.setMaxAge(0);
        response.addCookie(cookie);
    }
}
